{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1><font color=\"darkblue\">Trees</font></h1>\n",
    "\n",
    "- Recursive data structures\n",
    "\n",
    "> **Recursion**<br/>\n",
    "> To know recursion, you must first know recursion.\n",
    "\n",
    "> **Recursive Acronyms** <br/>\n",
    ">   GNU: GNU is Not Unix <br/>\n",
    ">   LAME: LAME Ain't an MP3 Encoder<br/>\n",
    ">   PIP: PIP Installs Packages\n",
    "\n",
    "- Used everywhere\n",
    "\n",
    "> Searches, decisions, etc...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# factorial using recursion\n",
    "def f(n):\n",
    "    if n>0: return n * f(n-1)\n",
    "    else: return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 24, 120,   2])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func = np.vectorize(f)\n",
    "func([4,5,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binary Tree\n",
    "- Connected nodes - special tree structures\n",
    "\n",
    "> There is one root node\n",
    "\n",
    "> Every node has maximum two nodes (left, right)\n",
    "\n",
    "> Leaves are the terminal nodes\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/f/f7/Binary_tree.svg\" alt=\"Binary tree.svg\" height=\"250\" width=\"200\" align=left>\n",
    "<!--\n",
    "<img src=\"files/Binary_tree.svg\" alt=\"Binary tree.svg\" height=\"250\" width=\"200\" align=left>\n",
    "-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class node(object):\n",
    "    \n",
    "    def __init__(self, data, left=None, right=None):\n",
    "        self.data = data\n",
    "        self.left = left\n",
    "        self.right = right\n",
    "   \n",
    "    def __repr__(self, i=0):\n",
    "        s = '\\t'*i + '[' + repr(self.data) + '] \\n'\n",
    "        if self.left is not None:  \n",
    "            s += self.left.__repr__(i+1)\n",
    "        if self.right: # same thing\n",
    "            s += self.right.__repr__(i+1)\n",
    "        return s\n",
    "    \n",
    "    def search(self, n):\n",
    "        if self.search_sub(n):\n",
    "            return \"Found number \"+str(n)\n",
    "        else:\n",
    "            return \"Didn't found number \"+str(n)\n",
    "        \n",
    "        \n",
    "    def search_sub(self, n):\n",
    "        if self is None:\n",
    "            return False\n",
    "        if (self.data == n):\n",
    "            return True\n",
    "        \n",
    "        result_left, result_right = False, False\n",
    "        if self.left is not None:\n",
    "            result_left = self.left.search_sub(n)\n",
    "        if self.right is not None:\n",
    "            result_right = self.right.search_sub(n)\n",
    "        \n",
    "        return result_left or result_right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2] \n",
       "\t[7] \n",
       "\t\t[2] \n",
       "\t\t[6] \n",
       "\t\t\t[5] \n",
       "\t\t\t[11] \n",
       "\t[5] \n",
       "\t\t[9] \n",
       "\t\t\t[4] "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "root = node(2, \n",
    "            node(7,\n",
    "                 node(2), \n",
    "                 node(6, node(5), node(11))),\n",
    "            node(5, None,\n",
    "                 node(9, node(4)))\n",
    "           )\n",
    "\n",
    "root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print (root.left.left.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2] \n",
       "\t[7] \n",
       "\t\t[2] \n",
       "\t\t\t[99] \n",
       "\t\t\t[999] \n",
       "\t\t[6] \n",
       "\t\t\t[5] \n",
       "\t\t\t[11] \n",
       "\t[5] \n",
       "\t\t[9] \n",
       "\t\t\t[4] "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "root.left.left.left = node(99)\n",
    "root.left.left.right = node(999)\n",
    "root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "root.right.right.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Didn't found number 100\n"
     ]
    }
   ],
   "source": [
    "print(root.search(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $n$-ary Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class node(object):\n",
    "    \n",
    "    def __init__(self, data, children=[]):\n",
    "        self.data = data\n",
    "        self.children = children\n",
    "        \n",
    "    def __repr__(self, i=0):\n",
    "        s = '\\t'*i + repr(self.data) + '\\n' \n",
    "        for child in self.children:\n",
    "            s += child.__repr__(i+1)\n",
    "        return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2\n",
       "\t7\n",
       "\t\t2\n",
       "\t\t6\n",
       "\t\t\t5\n",
       "\t\t\t11\n",
       "\t5\n",
       "\t\t9\n",
       "\t\t\t4"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# build a tree\n",
    "root = node(2, [ \n",
    "            node(7, [\n",
    "                node(2),\n",
    "                node(6, [\n",
    "                        node(5), \n",
    "                        node(11)])]),\n",
    "            node(5, [\n",
    "                node(9, [node(4)])])\n",
    "            ]);\n",
    "\n",
    "root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2\n",
       "\t7\n",
       "\t\t2\n",
       "\t\t6\n",
       "\t\t\t5\n",
       "\t\t\t11\n",
       "\t5\n",
       "\t\t9\n",
       "\t\t\t4\n",
       "\t999"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "root.children.append(node(999))\n",
    "root"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trees are everywhere!\n",
    "\n",
    "- Searching\n",
    "\n",
    "> $k$d-trees, B-tree, R-tree, ball trees, etc...\n",
    "\n",
    "> E.g., for nearest neighbor searches\n",
    "\n",
    "- Decisions \n",
    "\n",
    "> E.g., for classification "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $k$-d tree\n",
    "\n",
    "- Balanced tree\n",
    "- Split along axes\n",
    "\n",
    "Constructed from points, see Figure from Wikipedia<br/>\n",
    "{ (2,3), (5,4), (9,6), (4,7), (8,1), (7,2) }\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/Kdtree_2d.svg/1200px-Kdtree_2d.svg.png\" alt=\"Kdtree 2d.svg\" width=300 align=left> \n",
    "<!--\n",
    "<img src=\"files/1200px-Kdtree_2d.svg.png\" alt=\"Kdtree 2d.svg\" width=300 align=left> \n",
    "-->\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### <h1><font color=\"darkblue\">Decision Tree</font></h1>\n",
    "\n",
    "- Recursive partitioning of the training dataset\n",
    "\n",
    "> At a given node with dataset $D$ we look for the\n",
    "> best split \n",
    "\n",
    "> $\\theta = $ (feature $j$, threshold $t$) \n",
    "\n",
    "> such that the \n",
    "> partitions $D_{\\textrm{left}}(\\theta)$ and $D_{\\textrm{right}}(\\theta)$ have minimal *impurity*\n",
    "\n",
    "> $\\displaystyle I(\\theta) = \\frac{n_{\\textrm{left}}}{n}\\, H\\Big(D_{\\textrm{left}}(\\theta)\\Big) + \\frac{n_{\\textrm{right}}}{n}\\,H\\Big(D_{\\textrm{right}}(\\theta)\\Big)$\n",
    "\n",
    "- Different impurity functions $H(\\cdot)$\n",
    "\n",
    "> E.g., Gini with $K$ classes in the partition $D$\n",
    "\n",
    ">$\\displaystyle H(D) = \\sum_{i=1}^K p_i (1-p_i)$\n",
    "\n",
    "> Or variance for regression\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x108 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0,1,100)\n",
    "plt.figure(figsize=(3,1.5)); plt.plot(x, x*(1-x));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Toy Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.array([[.7,0],[1,.3],[1.1,0],[.9,0],[1,0],[1,-.1],[1,.1],[1,.2]],\n",
    "             dtype=np.float)\n",
    "c = np.array([ 0,0,0,0, 1,1,1, 2], dtype=np.float)\n",
    "plt.figure(figsize=(3,3))\n",
    "plt.subplot(111,aspect='equal'); plt.scatter(X[:,0],X[:,1],c=c,cmap='brg');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gini impurity of a partition\n",
    "\n",
    "- We have 3 classes total hence the sum for the entire dataset is\n",
    "\n",
    ">$ \\displaystyle H = \\frac{4}{8}\\left(1\\!-\\!\\frac{4}{8}\\right) \n",
    "     + \\frac{3}{8}\\left(1\\!-\\!\\frac{3}{8}\\right) \n",
    "     + \\frac{1}{8}\\left(1\\!-\\!\\frac{1}{8}\\right) $ $ \\displaystyle = \\frac{16}{64}\n",
    "     + \\frac{15}{64}\n",
    "     + \\frac{7}{64}\n",
    "     = \\frac{19}{32} = 0.59375$\n",
    "     \n",
    "- This is the root of the tree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Impurity of 2 partitions after first split\n",
    "\n",
    "- The root partition contains 3 classes hence the sum is\n",
    "\n",
    ">$ \\displaystyle H_{\\rm{}left} = \\frac{2}{2}\\left(1\\!-\\!\\frac{2}{2}\\right) + \\frac{0}{2}\\left(1\\!-\\!\\frac{0}{2}\\right) + \\frac{0}{2}\\left(1\\!-\\!\\frac{0}{2}\\right)= 0$\n",
    "\n",
    ">$ \\displaystyle H_{\\rm{}right} = \\frac{3}{6}\\left(1\\!-\\!\\frac{3}{6}\\right) \n",
    "     + \\frac{2}{6}\\left(1\\!-\\!\\frac{2}{6}\\right) \n",
    "     + \\frac{1}{6}\\left(1\\!-\\!\\frac{1}{6}\\right) $ \n",
    " $ \\displaystyle = \\frac{9}{36}\n",
    "     + \\frac{8}{36}\n",
    "     + \\frac{5}{36}\n",
    "     = \\frac{11}{18} $ $\\approx 0.61111111$\n",
    "\n",
    "> Cf. numbers above\n",
    "\n",
    "- Note importance of weighting by partition sizes!\n",
    "\n",
    "     \n",
    "### Impurity of partitions after second split\n",
    "- Threshhold: 0 on feature -2. Dummy variable means no further split on this partition.\n",
    ">$ \\displaystyle H_{\\rm{}root.left.left} = None$<br>\n",
    ">$ \\displaystyle H_{\\rm{}root.left.right} = None$\n",
    "- Threshhold: 0.15 on feature 1\n",
    ">$ \\displaystyle H_{\\rm{}root.right.left} = \\frac{3}{4}\\left(1\\!-\\!\\frac{3}{4}\\right) \n",
    "     + \\frac{1}{4}\\left(1\\!-\\!\\frac{1}{4}\\right) \n",
    "     + \\frac{0}{4}\\left(1\\!-\\!\\frac{0}{4}\\right) $ \n",
    " $ \\displaystyle = \\frac{3}{16}\n",
    "     + \\frac{3}{16}\n",
    "     + \\frac{0}{16}\n",
    "     = \\frac{6}{16} $ $= 0.375$<br>\n",
    ">$ \\displaystyle H_{\\rm{}root.right.right} = \\frac{1}{2}\\left(1\\!-\\!\\frac{1}{2}\\right) \n",
    "     + \\frac{1}{2}\\left(1\\!-\\!\\frac{1}{2}\\right) \n",
    "     + \\frac{0}{2}\\left(1\\!-\\!\\frac{0}{2}\\right) $ \n",
    " $ \\displaystyle = \\frac{1}{4}\n",
    "     + \\frac{1}{4}\n",
    "     + \\frac{0}{4}\n",
    "     = \\frac{1}{2} $ $= 0.5$\n",
    "\n",
    "### And so on\n",
    "### Check answer below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8 2 6 4 2]\n",
      "[0.59375    0.         0.61111111 0.375      0.5       ]\n",
      "[ 0 -2  1 -2 -2]\n",
      "[ 0.94999999 -2.          0.15       -2.         -2.        ]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import tree\n",
    "clf = tree.DecisionTreeClassifier(max_depth=2)\n",
    "clf.fit(X,c)\n",
    "\n",
    "print (clf.tree_.n_node_samples)\n",
    "print (clf.tree_.impurity)\n",
    "print (clf.tree_.feature)\n",
    "print (clf.tree_.threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "h = 0.01\n",
    "x,y = np.meshgrid(np.arange(X[:,0].min()-.5, X[:,0].max()+.5, h),\n",
    "               np.arange(X[:,1].min()-.5, X[:,1].max()+.5, h))\n",
    "grid = np.c_[x.ravel(),y.ravel()]\n",
    "\n",
    "# decision-surfaces as fn of max depth\n",
    "clf = tree.DecisionTreeClassifier(max_depth=2)\n",
    "z = clf.fit(X,c).predict(grid).reshape(x.shape)\n",
    "plt.figure(figsize=(3,3)); plt.subplot(111,aspect='equal')\n",
    "plt.contourf(x, y, z, cmap='Spectral_r')\n",
    "plt.scatter(X[:,0], X[:,1], c=c, cmap='brg');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advantages and disadvantages for decision tree classifier\n",
    "\n",
    "### Advantages  \n",
    "Advantage 1: Decision trees implicitly perform variable screening or feature selection       \n",
    "Advantage 2: Decision trees require relatively little effort from users for data preparation   \n",
    "Advantage 3: Nonlinear relationships between parameters do not affect tree performance   \n",
    "Advantage 4: The best feature of using trees for analytics - easy to interpret and explain to executives!\n",
    "    \n",
    "### Disadvantages\n",
    "1.Instability:     \n",
    "The reliability of the information in the decision tree depends on feeding the precise internal and external information at the onset. Even a small change in input data can at times, cause large changes in the tree.      \n",
    "\n",
    "2.Unwieldy:               \n",
    "Decision trees, while providing easy to view illustrations, can also be unwieldy. Even data that is perfectly divided into classes and uses only simple threshold tests may require a large decision tree. Large trees are not intelligible, and pose presentation difficulties."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example\n",
    "\n",
    "Use the sklearn routines to \n",
    "\n",
    "- Load the iris dataset and use the first 2 features\n",
    "- Run the decision tree classifier with different depths\n",
    "- Use cross-validation and plot the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New classes: [0 1]\n",
      "New data: (100, 2)\n"
     ]
    }
   ],
   "source": [
    "from sklearn import datasets\n",
    "\n",
    "iris = datasets.load_iris()\n",
    "X = iris.data[:,:2] # only first 2 features\n",
    "c = iris.target[:] # copy\n",
    "subset = c<2 # classes 0 and 1\n",
    "X,c = X[subset,:], c[subset]\n",
    "\n",
    "print ('New classes:', np.unique(c))\n",
    "print ('New data:', X.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(111,aspect='equal'); \n",
    "plt.scatter(X[:,0],X[:,1],c=c,cmap='brg');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# grid of points within the limits\n",
    "h = 0.01\n",
    "x,y = np.meshgrid(np.arange(X[:,0].min()-.5, X[:,0].max()+.5, h),\n",
    "               np.arange(X[:,1].min()-.5, X[:,1].max()+.5, h))\n",
    "grid = np.c_[x.ravel(),y.ravel()]\n",
    "\n",
    "# decision-surfaces as fn of max depth\n",
    "for depth in range(1,5):\n",
    "    clf = tree.DecisionTreeClassifier(max_depth=depth)\n",
    "    z = clf.fit(X,c).predict(grid).reshape(x.shape)\n",
    "    plt.figure(figsize=(3,3)); plt.subplot(111,aspect='equal')\n",
    "    plt.contourf(x, y, z, cmap='Spectral_r')\n",
    "    plt.scatter(X[:,0], X[:,1], c=c, cmap='gray');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 0.8, 0.8, 0.8, 1. , 1. , 0.8, 0.9, 0.9, 0.9])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# k-fold cross-validation \n",
    "from sklearn.model_selection import cross_val_score, KFold\n",
    "clf = tree.DecisionTreeClassifier(max_depth=1)\n",
    "cross_val_score(clf, X,c, cv=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 :\t 1.0 \t= 1.0\n",
      "1 :\t 0.8 \t= 0.8\n",
      "2 :\t 0.9 \t= 0.9\n",
      "3 :\t 0.9 \t= 0.9\n",
      "4 :\t 1.0 \t= 1.0\n",
      "5 :\t 0.9 \t= 0.9\n",
      "6 :\t 1.0 \t= 1.0\n",
      "7 :\t 0.7 \t= 0.7\n",
      "8 :\t 0.9 \t= 0.9\n",
      "9 :\t 0.8 \t= 0.8\n"
     ]
    }
   ],
   "source": [
    "# also by hand\n",
    "k_fold = KFold(n_splits=10,shuffle=True,random_state=42) \n",
    "for k, (train, test) in enumerate(k_fold.split(X)):\n",
    "    cpred = clf.fit(X[train],c[train]).predict(X[test])\n",
    "    print (k, ':\\t', (c[test]==cpred).sum() / float(test.size),\n",
    "        '\\t=', clf.score(X[test],c[test]) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0.8875 0.1186585905491512\n",
      "2 0.95 0.1274754878398196\n",
      "3 0.95 0.1274754878398196\n",
      "4 0.95 0.1274754878398196\n"
     ]
    }
   ],
   "source": [
    "# quality as fn of max depth\n",
    "for depth in range(1,5):\n",
    "    clf = tree.DecisionTreeClassifier(max_depth=depth)\n",
    "    s = cross_val_score(clf, X,c, cv=20)\n",
    "    ## fix the comparisons?\n",
    "    print (depth, s.mean(), s.std())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0.89 0.09433981132056604 0.7\n",
      "2 0.95 0.06708203932499368 0.8\n",
      "3 0.95 0.06708203932499368 0.8\n",
      "4 0.95 0.06708203932499368 0.8\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "k_fold = KFold(n_splits=10,shuffle=True,random_state=42) \n",
    "\n",
    "scores = dict() # store the cv score of each split\n",
    "for train, test in k_fold.split(X):\n",
    "    for depth in range(1,5):\n",
    "        clf = tree.DecisionTreeClassifier(max_depth=depth)\n",
    "        clf.fit(X[train],c[train])\n",
    "        score = clf.score(X[test],c[test])\n",
    "        if depth not in scores: scores[depth] = [] # empty \n",
    "        scores[depth].append(score) # list for this depth\n",
    "\n",
    "for depth in scores:\n",
    "    s = np.array(scores[depth])\n",
    "    print (depth, s.mean(), s.std(), s.min())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <h1><font color=\"darkblue\">Random Forest</font></h1>\n",
    "\n",
    "### Random Tree\n",
    "\n",
    "- Hard to pick the *best* in high dimensions (i.e., very expensive)\n",
    "\n",
    "> Instead we pick a number of random directions to search<br/>\n",
    "> and take the optimal split among those\n",
    "\n",
    "- A randomized tree will not be optimal but much faster to build\n",
    "\n",
    "We assume that the user knows about the construction of single classification trees. Random Forests grows many classification trees. To classify a new object from an input vector, put the input vector down each of the trees in the forest. Each tree gives a classification, and we say the tree \"votes\" for that class. The forest chooses the classification having the most votes (over all the trees in the forest). \n",
    "\n",
    "####  forest error rate \n",
    "it was shown that the forest error rate depends on two things:      \n",
    "(1)The correlation between any two trees in the forest. Increasing the correlation increases the forest error rate.     \n",
    "(2)The strength of each individual tree in the forest. A tree with a low error rate is a strong classifier. Increasing the strength of the individual trees decreases the forest error rate.    \n",
    "Reducing m reduces both the correlation and the strength. Increasing it increases both. Somewhere in between is an \"optimal\" range of m - usually quite wide.    \n",
    "\n",
    "#### No need for cross-validation \n",
    " In random forests, there is no need for cross-validation or a separate test set to get an unbiased estimate of the test set error. It is estimated internally. At the end of the run, take j to be the class that got most of the votes every time case n was oob. The proportion of times that j is not equal to the true class of n averaged over all cases is the oob error estimate. This has proven to be unbiased in many tests.\n",
    "#### Balancing prediction error\n",
    "In some data sets, the prediction error between classes is highly unbalanced. Some classes have a low prediction error, others a high. This occurs usually when one class is much larger than another. Then random forests, trying to minimize overall error rate, will keep the error rate low on the large class while letting the smaller classes have a larger error rate.   \n",
    "\n",
    "The error can balancing can be done by setting different weights for the classes.     \n",
    "\n",
    "The higher the weight a class is given, the more its error rate is decreased. A guide as to what weights to give is to make them inversely proportional to the class populations. \n",
    "\n",
    "#### Compare with Decision Tree\n",
    "##### Advantage\n",
    "Random forests overcome several problems with decision trees, including:     \n",
    "•Reduction in overfitting: by averaging several trees, there is a significantly lower risk of overfitting.     \n",
    "•Less variance: By using multiple trees, you reduce the chance of stumbling across a classifier that doesn’t perform well because of the relationship between the train and test data.     \n",
    "As a consequence, in almost all cases, random forests are more accurate than decision trees.   \n",
    "\n",
    "##### Disadvantage\n",
    "There are many disadvantages of using a random forest over a simple decision tree:     \n",
    "•It’s more complex.     \n",
    "•It’s hard to visualize the model or understand why it predicted something.    \n",
    "•It’s more difficult to implement.       \n",
    "•It’s more computationally expensive.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Relative Importance')"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn import datasets\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "#Load dataset\n",
    "iris = datasets.load_iris()\n",
    "X = iris.data[:,:2] # only first 2 features\n",
    "c = iris.target\n",
    "subset = c<2 # classes 0 and 1\n",
    "X,c = X[subset,:], c[subset]\n",
    "\n",
    "\n",
    "# grid of points within the limits to evaluate\n",
    "h = 0.01\n",
    "x,y = np.meshgrid(np.arange(X[:,0].min()-.5, X[:,0].max()+.5, h),\n",
    "               np.arange(X[:,1].min()-.5, X[:,1].max()+.5, h))\n",
    "grid = np.c_[x.ravel(),y.ravel()]\n",
    "\n",
    "\n",
    "# Fit random forest classifier\n",
    "clf = RandomForestClassifier(n_estimators=200,max_depth=2)\n",
    "z = clf.fit(X,c).predict(grid).reshape(x.shape)\n",
    "\n",
    "# Plot the result\n",
    "plt.figure(figsize=(4,4)); plt.subplot(111,aspect='equal')\n",
    "plt.contourf(x,y,z, cmap='Spectral_r')\n",
    "plt.scatter(X[:,0],X[:,1], c=c, cmap='gray');\n",
    "\n",
    "# No need, but no harm done doing so\n",
    "cross_val_score(clf, X,c, cv=10)\n",
    "\n",
    "\n",
    "# Random forest generate feature importance\n",
    "importances =clf.feature_importances_\n",
    "indices = np.argsort(importances)\n",
    "plt.figure()\n",
    "plt.title('Feature Importances')\n",
    "plt.barh(range(len(indices)), importances[indices], color='b', align='center')\n",
    "plt.yticks(range(len(indices)), np.array(iris.feature_names)[np.argsort(importances)])\n",
    "plt.xlabel('Relative Importance')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
